COMMENT ⊗   VALID 00006 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002		Part one: Functions as passive objects
C00009 00003		Part two: Functions as active objects
C00011 00004	     The Art of Computer Science: Undergraduate Special Topics Course
C00016 00005			       The Art of Computer Science
C00021 00006	What do  personal  computing, artificial  intelligence,  LOGO,  Smalltalk,
C00025 ENDMK
C⊗;
	Part one: Functions as passive objects

1  Notation
 	The role of notation in science
	 expressivity
	 subordination of detail
	 economy
	 amenability to proof
	The impact of computing on notation
	 executability
	 representability of algorithms
	The difficulties with programming languages

  Computation and interaction
	The relationship between language and its medium
	 why computing languages cannot be separated
	   from the programming env
	 cf. conversation and understanding
	The polarization between interaction and discipline
	 pascal vs. lisp  vs. ucsd pascal  vs smalltalk
	The polarization between rigor and hacking
	 basic vs. (lisp/scheme)


2  The language
3	Data domain: The whole numbers
	Algorithmic notation
	 conditional expressions
	 definitions
	   recursion
	 numerical examples
	computation as deduction
	   axioms for number theroy
	   rules of inference
	     substitution and simplification
		number theory
		conditional
	   the concept of proof
	    equivalence
	    termination
	Data Domain: symbolic expressions
	 the representability of programs
 	 abstract objects
	 constructors, selectors, and recognizers
	The mapping of expressions to data structures
	Non-numeric computation: examples
	  evaluation of polynomials
	  simplification of algebraic expressions
	  propositional logic: evaluation
	    ?theorem proving
	  binary trees (l-n-r) rep, sort, add, del
	  missionaries and cannibal
 	  game stuff

4  Evaluation
5	Deduction vs computation, again
	 systems for substitution and simplification
	 computation as controlled deduction
	 call-by-name vs. call-by-value
	Semantics of programming languages
	Representability of programs
	 a detailed discussion
	An evaluation algorithm
	 The operational view
	Implementation strategies
	 call-by-value
	 weak vs. strong conditional
	 simulation of substitution
	extending the evaluator
	 macros and read-macros: abbreviational convenience
	 iteration: language extension and special forms
	

6  A modern LISP: more data structuring
7	The idea of "first-class data"
	implementation-driven languages violate notational principles
	 arbitrary precision numbers
 	 Strings
	 Arrays
	 property-lists (flex records)

8  Property-lists and message passing
	classes as properties
	algorithms as message passing
	hieracharies and flavors
	  hierarchies as implementation simplification

9  Object-oriented programming
10	Smalltalk and Actors

11 Lexical vs dynamic scoping: the beginnings of active functions
	Evaluation revisited
	 functionals
	 the difficulty with functional arguments
	 variables: local, free, global
	 added complexity of functional values

12 Control: function vs algorithm
	an analysis of the evaluator
	 the run-time structure
	   stacks
	   stacks+access and control links
	   tree access, control stack
	   tree access, tree control

13 Applicative v.s. imperative
	control as a programming tool
	 side-effects
	  assignment, rplaca, rplacd

14 Implementation considerations
	implementation of the evaluation process
	 read
	  parsers and scanners
	   searching and hashing
	 print
	runtime language support
 	 i-j pairs
	 shallow versus deep
	run-time data support
	 numbers
	 arbitrary precision numbers
	 trees
	  programmer maintained
	  reference counting
	  garbage collection
	   mark sweep
	   copy-compacting
	    cheney
	    baker
	    henry&carl

15 Machines and compiling
16	The LISP machine
	Traditional machines as microcode
	Compilation
	 program representation
	  list structure
	  scheme hacks
	  p-code/byte code/MACRO
	  machine specific
	Hardware
	  LISP machine
	  Scheme chips

14 The Racks paper: a bridge  from passive to active
	Part two: Functions as active objects

1  Functions as first-class objects
  	Relationship between 
	  purity:lexical and
	  utility: dynamic
	interactive creation of functional objects
	 programming in "levels"

		
2  Applications of functional objects
     car,cdr, cons as:
	1. arrays and functional
	2. pure functional  (t, f)
	3. 1 as msg passing
3    stacks as functionals (gls/gjs)
4    multiprocessing (wand/aip)

5  Evaluation of Functionals
	evaluators for full funarg 
	evaluators for smalltalk (ingalls)

6  Applications of lisp-related computing
	cad
	nl
	business data bases  --must do much better here

7  The future of computing
	interactive programming
	language designs
	theory
	ai applications
     The Art of Computer Science: Undergraduate Special Topics Course

The point  of  the  course  is  to  present  the  fundamental  notions  of
computing.

The course has the same general  characteristic as that of the  functional
programming  class,  but  will  use  a  curriculum  based  on  access   to
interactive personal computers  as the  primary tool  for gaining  fluency
with the concepts and gaining an understanding of interactive computing.

The notions of computing are  quite simple, yet the contemporary  approach
tends to obfuscate rather than  illuminate.  At the concept level,  simple
ideas become buried in syntax:   algorithms are confused with  programming
language syntax;  computation is  confused  with compiling;  compiling  is
confused with syntax analysis.

On the technological side, the Practice of computing suffers from the dead
weight of twenty years of batch processing.  "Glass teletypes" create card
decks and text  editors manipulate card  images.  Alas, certain  computing
"methodologies"  even  glory  in  the  "discipline"  that  such  primitive
interaction forces one to endure.


Without an understanding  of fundamental  concepts, and  saddled with  the
outdated and  stilted programming  techniques, it  is not  suprising  that
computer-related productivity is falling.


Fortunately, the intellectual legacy of mathematical logic and be  coupled
with a few insights of modern  computing to supply an adequate  foundation
for modern computing.  The missing  ingredient in the traditional  setting
was the baroque computing engine that logicians used; a Turing machine  is
a dreadful  architecture.   The fundamentals  of  the new  formalism  were
discussed by John McCarthy  twenty years ago, and  have been the basis  of
the programming language named LISP. The new ingredient is the development
of the personal computing environment.  One cannot effectively learn about
computing without practicing  the art. Until  recently, appropriate  tools
for computing "practice" have  been restricted to research  establishments
for at  least two  reasons.   First, many  of  the ideas  about  effective
interactive environments have been the subject of research; secondly,  and
more immediate, the cost of these components has been extraordinally high.
Technology has changed that second  consideration, and the research  ideas
have reached a  synthesis stage. The  time is therefore  ripe to move  the
intellectual  and  methodological  and  technological  results  into   the
educational domain.  That is the intent of this course.
		       The Art of Computer Science

This course is a  challenge. I plan to  challenge your conception of  what
computing is  about, to  challenge  the traditional  view of  the  purpose
programming languages, to challenge the  usual conception of how one  does
programming, to challenge the traditional curriculum of computing, and  in
general to challenge your minds.

The course  is neither  mathematics nor  engineering; it  draws from  both
disciplines, as does all of computer science. The intent of the course  is
to investigate the phenomena  called computing at  a level of  abstraction
that will  allows us  to explicate  fundamental principles  that  underlie
computing theory and practice.

The texts for this  course are (1)  My  notes, (2) "Zen  and the Art  of
Motorcycle maintenance",  and  (3)  "Mindstroms: Computers, Children,  the
and Powerful Ideas"
programming lab notes.

These  class  notes  form  the   main  structure  of  the  technical   and
"meta-computational" perspective  that supports  the inquiry.   "Zen"  has
valuable insights in  the relationships between  art and science,  besides
the appropriate "tone" for this course. "Godel, Escher, Bach" is good fun;
an exemplary  book  showing  how  one can  present  complex  ideas  in  an
intuitive, yet faithful,  setting.  Much  of "GEB"  will show  up in  this
course.

A lab  session  is  associated  with  this  course.   Since  part  of  our
exploration involves computing, it is  a requirement that one  understands
the art of computing --oftern called "programming". Learning to program is
like learning to drive --both can profit from classroom work that explains
basic concepts.   However both  require "hands-on"  experience before  one
really gets "the  feel" of  the instrument.   As with  driving school,  we
should supply the students with the best available vehicles and guide them
in the process of applying the theory.

There are two important practical  lessons in the programming  experience:
first to develop an appreciation for abstraction and abstract programming,
and second  to develop  an understanding  of how  interactive  programming
differs from the traditional "batch" (or modified "batch")-procesing view.
Abstract  object-oriented  programming  carried  out  in  an   interactive
programming environment is the future of applied computing.

The course will be a "mind-stretcher", investigating:  computation, proof,
and truth;  computing formalism  and mathematical  notation; recursion  in
logic and computing; abstract algorithms and objects; symbolic computation
and Godel numbering;  evaluation and  LISP machines;  algorithms as  data;
data  as  algorithms;  compilation  and  LISP  machines;  pattern-directed
computation  and   logic;  interactive   computing  versus   "discipline";
implementation of LISP-like languages.

The course will be  self-contained: no prerequsites  other than a  healthy
intellectual curiousity and the self-discipline to think.

What do  personal  computing, artificial  intelligence,  LOGO,  Smalltalk,
LISP, Rubik's Cube, Robert Pirsig,  Doug Hofstadter, Oswald Spengler,  and
Seymour Papert have in common?  EECS 129.

LISP is the premier language for artificial intelligence development.

Smalltalk is a  powerful personal  computing language  developed at  Xerox
PARC.

LOGO is a language similar to Smalltalk, built at MIT and based on LISP.

Rubik's Cube is the mind-bending puzzle,  whose solution exists as a  LISP
program, complete with a color graphics solution on a LISP Machine.

Pirsig, the author of  "Zen and the Art  of Motorcycle Maintenance"  deals
with the issuse of quality and its realtionship to art and science.

Hofstadter wrote the Pulitzer Prize  winning "Godel, Escher, Bach".   This
work relates  logic, art,  and music  in a  interesting journey  into  the
recursive world.

"The Decline of the West"  by Spengler is a "meta-Hofstatder",  discussing
the rise and fall of Cultures in terms of their vison of mathematics.   Do
computers signify  the  death of  a  Civilization or  the  rise of  a  new
Culture?

And Seymour  Papert? He  authored  "Mindstorms: Computers,  Children,  and
Powerful Ideas", a tour through the visions that personal computing has in
store for the coming generation.

This spring the EECS department will offer a special topics class  dealing
with the computing  genre and  its impact  on our  culture.  It  is not  a
"computer literacy" course in the  traditional sense of the word,  neither
is it an EECS course in the traditional sense.  There's something here  to
offend everyone.

It is self-contained  study of  the fundamental  principles of  computing.
There's programming; experience with personal computers, issues of  style,
ethics, and aesthetics, there's  ai, there's cultural issues,  philosophy,
and generally exciting hard work.  It is a whirlwind tour through the next
ten years our computer-related society.